/**
 *链表：
 *  一种常见的基础数据结构，是一种线性表，但并不会按线性顺序存储数据，而是在每一个节点里存到下一个节点的指针
 *
 *  链表与数组：都是线性结构
 *  数组适合查找，遍历，是固定长度
 *  链表适合插入，删除，不宜过长，否则会导致遍历的性能下降
 */
class Test{
    public static void main(String[] args) {
        NodeManager manager=new NodeManager();
        manager.add(5);
        manager.add(4);
        manager.add(2);
        manager.add(3);
        manager.print();
        System.out.println("======del=======");
        manager.del(2);
        manager.print();
        System.out.println("查找4"+  manager.find(4));
        System.out.println("=========update=========");
        manager.update(3,10);
        manager.print();
        System.out.println('\n'+"=============insert===========");
        manager.insert(2,40);
        manager.print();
    }
}

 class NodeManager {
    private Node root;
    private int currentIndex=0;
   public void add(int data){
    if (root==null){
        root=new Node(data);
    }else{
        root.addNode(data);
    }
   }
   public void del(int data){
        if (root.getData()==data){
            this.root=root.next;
        }else{
            root.delNode(data);
        }
   }
   //查找是否存在节点
   public boolean find(int data){
       if (root==null){
           return false;
       }else if(root.getData()==data){
           return true;
       }else {
           return  this.root.findNode(data);
       }
   }
   public void update(int oldData,int newData){
       if (this.root!=null){
           if (root.getData()==oldData){
               root.setData(newData);
           }else {
               this.root.updateNode(oldData,newData);
           }
       }
   }
   public void insert(int index,int data){
        if (index<0) {
            return;
        }
        if (index==currentIndex){
            Node newNode=new Node(data);
            newNode.next=root;
            root=newNode;
        }else{
            root.insertNode(index, data);
        }
   }
     public void print(){
        if (root!=null){
            System.out.print(root.getData()+"-->");
            root.printNode();
        }

     }
    private class Node {
           private int data;
           private Node next;//把当前类型作为属性
        public Node(int data){
            this.data=data;
        }
          public  void setData(int data){
              this.data=data;
          }
          //添加节点
           public void addNode(int data){
                if (this.next==null)
                    this.next=new Node(data);
                else
                    this.next.addNode(data);
           }
           //删除节点
          public void delNode(int data){
            if (this.next!=null){
                if (this.next.data==data){
                    this.next=this.next.next;
                }else {
                    this.next.delNode(data);
                }
            }

          }
          public int getData(){
            return data;
          }
          //输出所有节点
          public void printNode(){
                if (this.next!=null){
                    System.out.print(this.next.data+"--->");
                    this.next.printNode();
                }
          }
          //查询
        public boolean findNode(int data){
            if (this.next!=null){
              if (this.next.getData()==data){
                  return true;
              }else{
                 return this.next.findNode(data);
              }
            }else
            return false;
        }
        //修改节点
        public void updateNode(int oldData,int newData){
            if (this.next!=null){
                if (this.next.getData()==oldData){
                    this.next.setData(newData);
                }else {
                    this.next.updateNode(oldData, newData);
                }
            }
        }
        //插入节点
        public void insertNode(int target,int data){
            currentIndex++;
            if (currentIndex==target){
                Node node=new Node(data);
                node.next=this.next;
                this.next=node;
            }
            else {
                this.next.insertNode(target,data);
            }
        }

    }
}
